package com.yoo.ons.base.adpater


/** 在原集合上追加一个元素.返回一个新的集合 */
fun <T> List<T>.add(item: T?): List<T> {
    if (item == null) return this
    return toMutableList().apply { add(item) }
}

/** 在原集合指定Index上追加一个元素.返回一个新的集合 */
fun <T> List<T>.add(index: Int, item: T?): List<T> {
    if (item == null) return this
    return toMutableList().apply { add(index, item) }
}

/** 在原集合指定Index上追加N个元素.返回一个新的集合 */
 fun <T> List<T>.addAll(items: List<T>?): List<T> {
    if (items == null) return this
    return toMutableList().apply { addAll(items) }
}

/** 在原集合上追加一个元素(若包含删除存在的).返回一个新的集合 */
fun <T> List<T>.insertOrReplace(item: T?): List<T> {
    if (item == null) return this
    return toMutableList().apply {
        if (contains(item)) remove(item)
        add(item)
    }
}

/** 在原集合指定Index上追加一个元素(若包含删除存在的).返回一个新的集合 */
fun <T> List<T>.insertOrReplace(index: Int, item: T?): List<T> {
    if (item == null) return this
    return toMutableList().apply {
        if (contains(item)) remove(item)
        add(index, item)
    }
}

/** 在原字典替换一个元素.返回一个新的字典 */
fun <T, K> Map<T, K>.insertOrReplace(
    key: T,
    value: K
): Map<T, K> {
    return toMutableMap().apply { put(key, value) }
}

/** 在原字典替换N个元素.返回一个新的字典 */
// rename to insertOrReplace
fun <T, K> Map<T, K>.mutablePutAll(items: List<Pair<T, K>>?): Map<T, K> {
    if (items == null) return this
    return toMutableMap().apply { putAll(items) }
}

/** 在原集合上替换满足条件的元素.返回一个新的集合 */
// rename to replaceIf
fun <T> List<T>.replace(block: (T) -> T): List<T> {
    return toMutableList().apply {
        forEachIndexed { index, t ->
            set(index, block(t))
        }
    }
}

fun <T> List<T>.replaceIf(block: (T) -> T?): List<T> {
    return toMutableList().apply {
        forEachIndexed { index, t ->
            block(t)?.let { set(index, it) }
        }
    }
}

/** 在原字典上替换满足条件的元素.返回一个新的字典 */
fun <T, K> Map<T, K>.replaceIf(block: (K) -> K?): Map<T, K> {
    return toMutableMap().apply {
        forEach { item -> block(item.value)?.let { set(item.key, it) }    }
    }
}


/** 在原集合上删除一个元素.返回一个新的集合 */
fun <T> List<T>.remove(item: T?): List<T> {
    if (item == null) return this
    return toMutableList().apply { remove(item) }
}

/** 在原集合上删除满足条件的元素.返回一个新的集合 */
// rename to removeIf
fun <T> List<T>.removeIfExist(
    condition: (T) -> Boolean
): List<T> {
    val list = toMutableList()
    val i = list.iterator()
    while (i.hasNext()) {
        if (condition(i.next())) i.remove()
    }
    return list
}

fun <T, K> Map<T, K>.replaceIfExist(
    key: T?,
    replace: (K) -> K
): Map<T, K> {
    if (key == null) return this
    return toMutableMap().apply { get(key)?.let(replace)?.let { put(key, it) } }
}


